using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("DeckPickerTrayDisplay")]
	public class DeckPickerTrayDisplay : MonoBehaviour
	{
		[Attribute38("DeckPickerTrayDisplay.HeroFullDefLoadedCallbackData")]
		public class HeroFullDefLoadedCallbackData : MonoClass
		{
			public HeroPickerButton HeroPickerButton => method_14<HeroPickerButton>("get_HeroPickerButton", Array.Empty<object>());

			public TAG_PREMIUM Premium => method_11<TAG_PREMIUM>("get_Premium", Array.Empty<object>());

			public HeroFullDefLoadedCallbackData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HeroFullDefLoadedCallbackData(IntPtr address)
				: this(address, "HeroFullDefLoadedCallbackData")
			{
			}
		}

		public enum SetRotationTutorialState
		{
			INACTIVE,
			READY,
			SHOW_TUTORIAL_POPUPS,
			SWITCH_TO_STANDARD,
			SHOW_QUEST_LOG
		}

		public GameObject m_randomDeckPickerTray => method_3<GameObject>("m_randomDeckPickerTray");

		public Transform m_Hero_Bone => method_3<Transform>("m_Hero_Bone");

		public Transform m_Hero_BoneDown => method_3<Transform>("m_Hero_BoneDown");

		public Transform m_HeroPower_Bone => method_3<Transform>("m_HeroPower_Bone");

		public Transform m_HeroPower_BoneDown => method_3<Transform>("m_HeroPower_BoneDown");

		public GameObject m_heroPowerShadowQuad => method_3<GameObject>("m_heroPowerShadowQuad");

		public Transform m_rankedPlayButtonsBone => method_3<Transform>("m_rankedPlayButtonsBone");

		public Texture m_emptyHeroTexture => method_3<Texture>("m_emptyHeroTexture");

		public UberText m_heroName => method_3<UberText>("m_heroName");

		public UberText m_modeName => method_3<UberText>("m_modeName");

		public UIBButton m_backButton => method_3<UIBButton>("m_backButton");

		public PlayButton m_playButton => method_3<PlayButton>("m_playButton");

		public FiresideGatheringPlayButtonLantern m_FiresideGatheringPlayButtonLantern => method_3<FiresideGatheringPlayButtonLantern>("m_FiresideGatheringPlayButtonLantern");

		public NestedPrefab m_leftArrowNestedPrefab => method_3<NestedPrefab>("m_leftArrowNestedPrefab");

		public NestedPrefab m_rightArrowNestedPrefab => method_3<NestedPrefab>("m_rightArrowNestedPrefab");

		public GameObject m_randomTray => method_3<GameObject>("m_randomTray");

		public GameObject m_trayFrame => method_3<GameObject>("m_trayFrame");

		public GameObject m_modeLabelBg => method_3<GameObject>("m_modeLabelBg");

		public GameObject m_randomDecksShownBone => method_3<GameObject>("m_randomDecksShownBone");

		public GameObject m_randomDecksHiddenBone => method_3<GameObject>("m_randomDecksHiddenBone");

		public GameObject m_suckedInRandomDecksBone => method_3<GameObject>("m_suckedInRandomDecksBone");

		public GameObject m_heroPrefab => method_3<GameObject>("m_heroPrefab");

		public Vector3 m_heroPickerButtonStart => method_2<Vector3>("m_heroPickerButtonStart");

		public Vector3 m_heroPickerButtonScale => method_2<Vector3>("m_heroPickerButtonScale");

		public float m_heroPickerButtonHorizontalSpacing => method_2<float>("m_heroPickerButtonHorizontalSpacing");

		public float m_heroPickerButtonVerticalSpacing => method_2<float>("m_heroPickerButtonVerticalSpacing");

		public GameObject m_basicDeckPageContainer => method_3<GameObject>("m_basicDeckPageContainer");

		public List<NestedPrefab> m_customDeckPageContainers => method_3<Class271<NestedPrefab>>("m_customDeckPageContainers")?.method_25();

		public GameObject m_tooltipPrefab => method_3<GameObject>("m_tooltipPrefab");

		public Transform m_tooltipBone => method_3<Transform>("m_tooltipBone");

		public HeroXPBar m_xpBarPrefab => method_3<HeroXPBar>("m_xpBarPrefab");

		public GameObject m_rankedWinsPlate => method_3<GameObject>("m_rankedWinsPlate");

		public UberText m_rankedWins => method_3<UberText>("m_rankedWins");

		public BoxCollider m_expoClickBlocker => method_3<BoxCollider>("m_expoClickBlocker");

		public GameObject m_hierarchyDeckTray => method_3<GameObject>("m_hierarchyDeckTray");

		public GameObject m_hierarchyDetails => method_3<GameObject>("m_hierarchyDetails");

		public MissingStandardDeckDisplay m_missingStandardDeckDisplay => method_3<MissingStandardDeckDisplay>("m_missingStandardDeckDisplay");

		public UIBButton m_collectionButton => method_3<UIBButton>("m_collectionButton");

		public HighlightState m_collectionButtonGlow => method_3<HighlightState>("m_collectionButtonGlow");

		public GameObject m_labelDecoration => method_3<GameObject>("m_labelDecoration");

		public List<GameObject> m_premadeDeckGlowBurstObjects => method_3<Class271<GameObject>>("m_premadeDeckGlowBurstObjects")?.method_25();

		public NestedPrefab m_switchFormatButtonContainer => method_3<NestedPrefab>("m_switchFormatButtonContainer");

		public SwitchFormatButton m_switchFormatButton => method_3<SwitchFormatButton>("m_switchFormatButton");

		public GameObject m_TheClockButtonBone => method_3<GameObject>("m_TheClockButtonBone");

		public string m_standardTransitionSound => method_4("m_standardTransitionSound");

		public string m_wildTransitionSound => method_4("m_wildTransitionSound");

		public SlidingTray m_rankedDetailsTray => method_3<SlidingTray>("m_rankedDetailsTray");

		public GameObject m_detailsTrayFrame => method_3<GameObject>("m_detailsTrayFrame");

		public Transform m_medalBone_phone => method_3<Transform>("m_medalBone_phone");

		public Mesh m_alternateDetailsTrayMesh => method_3<Mesh>("m_alternateDetailsTrayMesh");

		public Material m_arrowButtonShadowMaterial => method_3<Material>("m_arrowButtonShadowMaterial");

		public static int MAX_PRECON_DECKS_TO_DISPLAY => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "MAX_PRECON_DECKS_TO_DISPLAY");

		public static float TRAY_SLIDE_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "TRAY_SLIDE_TIME");

		public static float TRAY_SINK_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "TRAY_SINK_TIME");

		public static Vector3 INNKEEPER_QUOTE_POS => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "INNKEEPER_QUOTE_POS");

		public bool m_heroChosen => method_2<bool>("m_heroChosen");

		public List<TAG_CLASS> HERO_CLASSES => method_3<Class270<TAG_CLASS>>("HERO_CLASSES")?.method_25();

		public List<HeroPickerButton> m_heroButtons => method_3<Class271<HeroPickerButton>>("m_heroButtons")?.method_25();

		public Actor m_heroActor => method_3<Actor>("m_heroActor");

		public UIBButton m_leftArrow => method_3<UIBButton>("m_leftArrow");

		public UIBButton m_rightArrow => method_3<UIBButton>("m_rightArrow");

		public PegUIElement m_heroPower => method_3<PegUIElement>("m_heroPower");

		public Actor m_heroPowerActor => method_3<Actor>("m_heroPowerActor");

		public PegUIElement m_goldenHeroPower => method_3<PegUIElement>("m_goldenHeroPower");

		public Actor m_goldenHeroPowerActor => method_3<Actor>("m_goldenHeroPowerActor");

		public bool m_isMouseOverHeroPower => method_2<bool>("m_isMouseOverHeroPower");

		public FullDef m_selectedHeroPowerFullDef => method_3<FullDef>("m_selectedHeroPowerFullDef");

		public Actor m_heroPowerBigCard => method_3<Actor>("m_heroPowerBigCard");

		public Actor m_goldenHeroPowerBigCard => method_3<Actor>("m_goldenHeroPowerBigCard");

		public HeroXPBar m_xpBar => method_3<HeroXPBar>("m_xpBar");

		public HeroPickerButton m_selectedHeroButton => method_3<HeroPickerButton>("m_selectedHeroButton");

		public CollectionDeckBoxVisual m_selectedCustomDeckBox => method_3<CollectionDeckBoxVisual>("m_selectedCustomDeckBox");

		public DeckPickerMode m_deckPickerMode => method_2<DeckPickerMode>("m_deckPickerMode");

		public int m_currentPageIndex => method_2<int>("m_currentPageIndex");

		public string gameMode => method_4("gameMode");

		public Vector2 m_keyholeTextureOffset => method_2<Vector2>("m_keyholeTextureOffset");

		public string m_selectedHeroName => method_4("m_selectedHeroName");

		public RankedPlayDisplay m_rankedPlayDisplay => method_3<RankedPlayDisplay>("m_rankedPlayDisplay");

		public int m_numDecks => method_2<int>("m_numDecks");

		public int m_numPagesToShow => method_2<int>("m_numPagesToShow");

		public TooltipPanel m_tooltip => method_3<TooltipPanel>("m_tooltip");

		public List<CustomDeckPage> m_customPages => method_3<Class271<CustomDeckPage>>("m_customPages")?.method_25();

		public int m_heroDefsLoading => method_2<int>("m_heroDefsLoading");

		public bool m_buttonAchievementsInitialized => method_2<bool>("m_buttonAchievementsInitialized");

		public bool m_delayButtonAnims => method_2<bool>("m_delayButtonAnims");

		public bool m_Loaded => method_2<bool>("m_Loaded");

		public Notification m_expoThankQuote => method_3<Notification>("m_expoThankQuote");

		public Notification m_expoIntroQuote => method_3<Notification>("m_expoIntroQuote");

		public bool m_needUnlockAllHeroesTransition => method_2<bool>("m_needUnlockAllHeroesTransition");

		public float m_numCardsPerClass => method_2<float>("m_numCardsPerClass");

		public bool m_isUsingWildVisuals => method_2<bool>("m_isUsingWildVisuals");

		public Notification m_switchFormatPopup => method_3<Notification>("m_switchFormatPopup");

		public Notification m_innkeeperQuote => method_3<Notification>("m_innkeeperQuote");

		public bool m_showStandardComingSoonNotice => method_2<bool>("m_showStandardComingSoonNotice");

		public GameLayer m_defaultDetailsLayer => method_2<GameLayer>("m_defaultDetailsLayer");

		public bool m_doingUnlockAllHeroesTransition => method_2<bool>("m_doingUnlockAllHeroesTransition");

		public SlidingTray m_slidingTray => method_3<SlidingTray>("m_slidingTray");

		public bool m_innkeeperQuoteFinished => method_2<bool>("m_innkeeperQuoteFinished");

		public GameObject m_formatTutorialPopUpPrefab => method_3<GameObject>("m_formatTutorialPopUpPrefab");

		public Transform m_formatTutorialPopUpBone => method_3<Transform>("m_formatTutorialPopUpBone");

		public Transform m_Switch_Format_Notification_Bone => method_3<Transform>("m_Switch_Format_Notification_Bone");

		public PegUIElement m_clickCatcher => method_3<PegUIElement>("m_clickCatcher");

		public string m_formatPopUpShowSound => method_4("m_formatPopUpShowSound");

		public string m_formatPopUpHideSound => method_4("m_formatPopUpHideSound");

		public string m_wildDeckTransitionSound => method_4("m_wildDeckTransitionSound");

		public SetRotationTutorialState m_setRotationTutorialState => method_2<SetRotationTutorialState>("m_setRotationTutorialState");

		public float m_showQuestPause => method_2<float>("m_showQuestPause");

		public float m_playVOPause => method_2<float>("m_playVOPause");

		public bool m_shouldContinue => method_2<bool>("m_shouldContinue");

		public List<long> m_noticeIdsToAck => method_3<Class270<long>>("m_noticeIdsToAck")?.method_25();

		public DeckPickerTrayDisplay(IntPtr address, string className)
			: base(address, className)
		{
		}

		public DeckPickerTrayDisplay(IntPtr address)
			: this(address, "DeckPickerTrayDisplay")
		{
		}

		public static DeckPickerTrayDisplay Get()
		{
			return MonoClass.smethod_15<DeckPickerTrayDisplay>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "Get", Array.Empty<object>());
		}

		public static bool OnNavigateBack()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "OnNavigateBack", Array.Empty<object>());
		}

		public static bool IsBackingOut()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "IsBackingOut", Array.Empty<object>());
		}

		public static void BackOutToHub()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "BackOutToHub");
		}

		public static void BackOutToFiresideGathering()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "DeckPickerTrayDisplay", "BackOutToFiresideGathering");
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Init()
		{
			method_8("Init");
		}

		public bool IsShowingCustomDecks()
		{
			return method_11<bool>("IsShowingCustomDecks", Array.Empty<object>());
		}

		public void SuckInFinished()
		{
			method_8("SuckInFinished");
		}

		public void OnShowSecondPage(UIEvent e)
		{
			method_8("OnShowSecondPage", e);
		}

		public void ResetCurrentMode()
		{
			method_8("ResetCurrentMode");
		}

		public int GetSelectedHeroLevel()
		{
			return method_11<int>("GetSelectedHeroLevel", Array.Empty<object>());
		}

		public void SetPlayButtonText(string text)
		{
			method_8("SetPlayButtonText", text);
		}

		public void ToggleRankedDetailsTray(bool shown)
		{
			method_8("ToggleRankedDetailsTray", shown);
		}

		public long GetSelectedDeckID()
		{
			return method_11<long>("GetSelectedDeckID", Array.Empty<object>());
		}

		public bool GetSelectDeckIsWild()
		{
			return method_11<bool>("GetSelectDeckIsWild", Array.Empty<object>());
		}

		public CollectionDeck GetSelectedCollectionDeck()
		{
			return method_14<CollectionDeck>("GetSelectedCollectionDeck", Array.Empty<object>());
		}

		public void SetHeaderText(string text)
		{
			method_8("SetHeaderText", text);
		}

		public void UpdateCreateDeckText()
		{
			method_8("UpdateCreateDeckText");
		}

		public bool UpdateRankedClassWinsPlate()
		{
			return method_11<bool>("UpdateRankedClassWinsPlate", Array.Empty<object>());
		}

		public void UpdateMissingStandardDeckTray(bool animateInTray)
		{
			method_8("UpdateMissingStandardDeckTray", animateInTray);
		}

		public bool IsMissingStandardDeckTrayShown()
		{
			return method_11<bool>("IsMissingStandardDeckTrayShown", Array.Empty<object>());
		}

		public void Unload()
		{
			method_8("Unload");
		}

		public void OnApplicationPause(bool pauseStatus)
		{
			method_8("OnApplicationPause", pauseStatus);
		}

		public void OnServerGameStarted()
		{
			method_8("OnServerGameStarted");
		}

		public void OnServerGameCanceled()
		{
			method_8("OnServerGameCanceled");
		}

		public bool IsLoaded()
		{
			return method_11<bool>("IsLoaded", Array.Empty<object>());
		}

		public void HandleGameStartupFailure()
		{
			method_8("HandleGameStartupFailure");
		}

		public void SetHeroDetailsTrayToIgnoreFullScreenEffects(bool ignoreEffects)
		{
			method_8("SetHeroDetailsTrayToIgnoreFullScreenEffects", ignoreEffects);
		}

		public void UpdateRankedPlayDisplay()
		{
			method_8("UpdateRankedPlayDisplay");
		}

		public void ShowClickedWildDeckInStandardPopup()
		{
			method_8("ShowClickedWildDeckInStandardPopup");
		}

		public void ShowSwitchToWildTutorialIfNecessary()
		{
			method_8("ShowSwitchToWildTutorialIfNecessary");
		}

		public void SkipHeroSelectionAndCloseTray()
		{
			method_8("SkipHeroSelectionAndCloseTray");
		}

		public void OnModeSwitchedAfterSkippingHeroSelection()
		{
			method_8("OnModeSwitchedAfterSkippingHeroSelection");
		}

		public void InitForMode(SceneMgr.Mode mode)
		{
			method_8("InitForMode", mode);
		}

		public void UpdateFormat_Tournament()
		{
			method_8("UpdateFormat_Tournament");
		}

		public void UpdateFormat_CollectionManager()
		{
			method_8("UpdateFormat_CollectionManager");
		}

		public void UpdateCustomTournamentBackgroundAndDecks()
		{
			method_8("UpdateCustomTournamentBackgroundAndDecks");
		}

		public void SetHeaderForTavernBrawl()
		{
			method_8("SetHeaderForTavernBrawl");
		}

		public void SetTexturesForTavernBrawl()
		{
			method_8("SetTexturesForTavernBrawl");
		}

		public void InitHeroPickerButtons()
		{
			method_8("InitHeroPickerButtons");
		}

		public void InitCustomPages()
		{
			method_8("InitCustomPages");
		}

		public void InitMode()
		{
			method_8("InitMode");
		}

		public void InitExpoDemoMode()
		{
			method_8("InitExpoDemoMode");
		}

		public void ShowIntroQuote()
		{
			method_8("ShowIntroQuote");
		}

		public void EnableExpoClickBlocker(bool enable)
		{
			method_8("EnableExpoClickBlocker", enable);
		}

		public void HideDemoQuotes()
		{
			method_8("HideDemoQuotes");
		}

		public void HideIntroQuote()
		{
			method_8("HideIntroQuote");
		}

		public void HideSetRotationNotifications()
		{
			method_8("HideSetRotationNotifications");
		}

		public void OnTransitionFromGameplayFinished(bool cutoff, object userData)
		{
			method_8("OnTransitionFromGameplayFinished", cutoff, userData);
		}

		public void CollectionButtonPress(UIEvent e)
		{
			method_8("CollectionButtonPress", e);
		}

		public void BackButtonPress(UIEvent e)
		{
			method_8("BackButtonPress", e);
		}

		public void SwitchFormatButtonPress(UIEvent e)
		{
			method_8("SwitchFormatButtonPress", e);
		}

		public void OnStandardComingSoonResponse(BasicPopup.Response response, object userData)
		{
			method_8("OnStandardComingSoonResponse", response, userData);
		}

		public void SwitchFormatButtonRollover(UIEvent e)
		{
			method_8("SwitchFormatButtonRollover", e);
		}

		public void SwitchFormatButtonRollout(UIEvent e)
		{
			method_8("SwitchFormatButtonRollout", e);
		}

		public void PreUnload()
		{
			method_8("PreUnload");
		}

		public void ShowSecondPage(bool skipTraySlidingAnimation)
		{
			method_8("ShowSecondPage", skipTraySlidingAnimation);
		}

		public bool ShouldHandleBoxTransition()
		{
			return method_11<bool>("ShouldHandleBoxTransition", Array.Empty<object>());
		}

		public void OnBoxTransitionFinished(object userData)
		{
			method_8("OnBoxTransitionFinished", userData);
		}

		public void OnScenePreUnload(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnScenePreUnload", prevMode, prevScene, userData);
		}

		public void LowerHeroButtons()
		{
			method_8("LowerHeroButtons");
		}

		public void RaiseHeroButtons()
		{
			method_8("RaiseHeroButtons");
		}

		public void OnShowFirstPage(UIEvent e)
		{
			method_8("OnShowFirstPage", e);
		}

		public void ShowFirstPage()
		{
			method_8("ShowFirstPage");
		}

		public void SuckInPreconDecks()
		{
			method_8("SuckInPreconDecks");
		}

		public void OnCustomDeckPressed(CollectionDeckBoxVisual deckbox, bool showTrayForPhone)
		{
			method_8("OnCustomDeckPressed", deckbox, showTrayForPhone);
		}

		public void SelectCustomDeck(CollectionDeckBoxVisual deckbox, bool showTrayForPhone)
		{
			method_8("SelectCustomDeck", deckbox, showTrayForPhone);
		}

		public void ShowBasicDeckWarning(CollectionDeckBoxVisual deckbox)
		{
			method_8("ShowBasicDeckWarning", deckbox);
		}

		public void HeroPressed(UIEvent e)
		{
			method_8("HeroPressed", e);
		}

		public void SelectHero(HeroPickerButton button, bool showTrayForPhone)
		{
			method_8("SelectHero", button, showTrayForPhone);
		}

		public void UpdateHeroLockedTooltip(bool isLocked)
		{
			method_8("UpdateHeroLockedTooltip", isLocked);
		}

		public void DeselectLastSelectedHero()
		{
			method_8("DeselectLastSelectedHero");
		}

		public void Deselect()
		{
			method_8("Deselect");
		}

		public void MouseOverHero(UIEvent e)
		{
			method_8("MouseOverHero", e);
		}

		public void MouseOutHero(UIEvent e)
		{
			method_8("MouseOutHero", e);
		}

		public void UpdateHeroInfo(CollectionDeckBoxVisual deckBox)
		{
			method_9("UpdateHeroInfo", new Class276.Enum20[1] { Class276.Enum20.Class }, deckBox);
		}

		public void UpdateHeroInfo(HeroPickerButton button)
		{
			method_9("UpdateHeroInfo", new Class276.Enum20[1] { Class276.Enum20.Class }, button);
		}

		public void UpdateHeroInfo(FullDef fullDef, string heroName, TAG_PREMIUM premium)
		{
			method_9("UpdateHeroInfo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.ValueType
			}, fullDef, heroName, premium);
		}

		public void UpdateHeroPowerInfo(FullDef def, TAG_PREMIUM premium)
		{
			method_8("UpdateHeroPowerInfo", def, premium);
		}

		public void MouseOverHeroPower(UIEvent e)
		{
			method_8("MouseOverHeroPower", e);
		}

		public void MouseOutHeroPower(UIEvent e)
		{
			method_8("MouseOutHeroPower", e);
		}

		public void LoadHeroPowerCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("LoadHeroPowerCallback", assetRef, go, callbackData);
		}

		public void LoadGoldenHeroPowerCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("LoadGoldenHeroPowerCallback", assetRef, go, callbackData);
		}

		public void ShowHeroPowerBigCard()
		{
			method_8("ShowHeroPowerBigCard");
		}

		public void UpdateCustomHeroPowerBigCard(GameObject heroPowerBigCard)
		{
			method_8("UpdateCustomHeroPowerBigCard", heroPowerBigCard);
		}

		public void ShowGoldenHeroPowerBigCard()
		{
			method_8("ShowGoldenHeroPowerBigCard");
		}

		public void UpdateTrayTransitionValues(bool isWild, bool showVineGlowBurst)
		{
			method_8("UpdateTrayTransitionValues", isWild, showVineGlowBurst);
		}

		public void SetTrayTextures(Texture standardTexture, Texture wildTexture)
		{
			method_8("SetTrayTextures", standardTexture, wildTexture);
		}

		public void SetCustomTrayTextures(Texture standardTexture, Texture wildTexture)
		{
			method_8("SetCustomTrayTextures", standardTexture, wildTexture);
		}

		public void SetDetailsTrayTextures(Texture standardTexture, Texture wildTexture)
		{
			method_8("SetDetailsTrayTextures", standardTexture, wildTexture);
		}

		public void DisableHeroButtons()
		{
			method_8("DisableHeroButtons");
		}

		public void EnableHeroButtons()
		{
			method_8("EnableHeroButtons");
		}

		public HeroPickerButton GetPreconButtonForClass(TAG_CLASS classType)
		{
			return method_14<HeroPickerButton>("GetPreconButtonForClass", new object[1] { classType });
		}

		public void RankedPlayButtonsLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("RankedPlayButtonsLoaded", assetRef, go, callbackData);
		}

		public void OnMedalChanged(NetCache.NetCacheMedalInfo medalInfo)
		{
			method_8("OnMedalChanged", medalInfo);
		}

		public void PlayGameButtonRelease(UIEvent e)
		{
			method_8("PlayGameButtonRelease", e);
		}

		public void EnableBackButton(bool enable)
		{
			method_8("EnableBackButton", enable);
		}

		public void EnablePlayButton(bool enable)
		{
			method_8("EnablePlayButton", enable);
		}

		public void EnableCollectionButton(bool enable)
		{
			method_8("EnableCollectionButton", enable);
		}

		public void UpdateCollectionButtonGlow()
		{
			method_8("UpdateCollectionButtonGlow");
		}

		public void ShowHero()
		{
			method_8("ShowHero");
		}

		public void ShowPreconHero(bool show)
		{
			method_8("ShowPreconHero", show);
		}

		public void RaiseHero()
		{
			method_8("RaiseHero");
		}

		public void LowerHero()
		{
			method_8("LowerHero");
		}

		public void HideAllPreconHighlights()
		{
			method_8("HideAllPreconHighlights");
		}

		public void ShowPreconHighlights()
		{
			method_8("ShowPreconHighlights");
		}

		public void PlayGame()
		{
			method_8("PlayGame");
		}

		public void SelectHeroForCollectionManager()
		{
			method_8("SelectHeroForCollectionManager");
		}

		public void OnSlidingTrayToggled(bool isShowing)
		{
			method_8("OnSlidingTrayToggled", isShowing);
		}

		public bool CustomPagesReady()
		{
			return method_11<bool>("CustomPagesReady", Array.Empty<object>());
		}

		public void InitRichPresence()
		{
			method_8("InitRichPresence");
		}

		public void SetSelectionAndPageFromOptions()
		{
			method_8("SetSelectionAndPageFromOptions");
		}

		public void OnFriendChallengeWaitingForOpponentDialogResponse(AlertPopup.Response response, object userData)
		{
			method_8("OnFriendChallengeWaitingForOpponentDialogResponse", response, userData);
		}

		public void OnFriendChallengeChanged(FriendChallengeEvent challengeEvent, BnetPlayer player, object userData)
		{
			method_8("OnFriendChallengeChanged", challengeEvent, player, userData);
		}

		public void GoBackUntilOnNavigateBackCalled()
		{
			method_8("GoBackUntilOnNavigateBackCalled");
		}

		public void OnHeroFullDefLoaded(string cardId, FullDef fullDef, object userData)
		{
			method_8("OnHeroFullDefLoaded", cardId, fullDef, userData);
		}

		public void LoadHero()
		{
			method_8("LoadHero");
		}

		public void OnHeroActorLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnHeroActorLoaded", assetRef, go, callbackData);
		}

		public void LoadHeroPower()
		{
			method_8("LoadHeroPower");
		}

		public void OnHeroPowerActorLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnHeroPowerActorLoaded", assetRef, go, callbackData);
		}

		public void LoadGoldenHeroPower()
		{
			method_8("LoadGoldenHeroPower");
		}

		public void OnGoldenHeroPowerActorLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnGoldenHeroPowerActorLoaded", assetRef, go, callbackData);
		}

		public void FireDeckTrayLoadedEvent()
		{
			method_8("FireDeckTrayLoadedEvent");
		}

		public bool ShouldShowHeroPower()
		{
			return method_11<bool>("ShouldShowHeroPower", Array.Empty<object>());
		}

		public bool IsChoosingHero()
		{
			return method_11<bool>("IsChoosingHero", Array.Empty<object>());
		}

		public bool ShouldShowCollectionButton()
		{
			return method_11<bool>("ShouldShowCollectionButton", Array.Empty<object>());
		}

		public bool IsChoosingHeroForTavernBrawlChallenge()
		{
			return method_11<bool>("IsChoosingHeroForTavernBrawlChallenge", Array.Empty<object>());
		}

		public bool IsInFiresideGatheringAndInBrawlMode()
		{
			return method_11<bool>("IsInFiresideGatheringAndInBrawlMode", Array.Empty<object>());
		}

		public bool ShouldGlowCollectionButton()
		{
			return method_11<bool>("ShouldGlowCollectionButton", Array.Empty<object>());
		}

		public bool HaveDecksThatNeedNames()
		{
			return method_11<bool>("HaveDecksThatNeedNames", Array.Empty<object>());
		}

		public uint GetNumValidStandardDecks()
		{
			return method_11<uint>("GetNumValidStandardDecks", Array.Empty<object>());
		}

		public bool HaveUnseenBasicCards()
		{
			return method_11<bool>("HaveUnseenBasicCards", Array.Empty<object>());
		}

		public void InnkeeperCelebrationFinished()
		{
			method_8("InnkeeperCelebrationFinished");
		}

		public void ShowInnkeeperQuoteIfNeeded()
		{
			method_8("ShowInnkeeperQuoteIfNeeded");
		}

		public bool ShouldShowCustomDecks()
		{
			return method_11<bool>("ShouldShowCustomDecks", Array.Empty<object>());
		}

		public bool ShouldShowPreconDecks()
		{
			return method_11<bool>("ShouldShowPreconDecks", Array.Empty<object>());
		}

		public void InitSetRotationTutorial(bool veteranFlow)
		{
			method_8("InitSetRotationTutorial", veteranFlow);
		}

		public void StartSetRotationTutorial()
		{
			method_8("StartSetRotationTutorial");
		}

		public void ContinueTutorial(DialogBase dialog, object userData)
		{
			method_8("ContinueTutorial", dialog, userData);
		}

		public void StartSwitchToStandard()
		{
			method_8("StartSwitchToStandard");
		}

		public void OnSwitchFormatReleased(UIEvent e)
		{
			method_8("OnSwitchFormatReleased", e);
		}

		public void PlayTransitionSounds()
		{
			method_8("PlayTransitionSounds");
		}

		public void MarkSetRotationComplete()
		{
			method_8("MarkSetRotationComplete");
		}

		public int GetCompensationDust()
		{
			return method_11<int>("GetCompensationDust", Array.Empty<object>());
		}

		public void OnWelcomeQuestDismiss()
		{
			method_8("OnWelcomeQuestDismiss");
		}

		public void OnTutorialVOEnded()
		{
			method_8("OnTutorialVOEnded");
		}

		public void SwitchFormatTypeAndRankedPlayMode(VisualsFormatType newVisualsFormatType)
		{
			method_8("SwitchFormatTypeAndRankedPlayMode", newVisualsFormatType);
		}

		public void ShowPage(int pageNum, bool skipTraySlidingAnimation = false)
		{
			method_8("ShowPage", pageNum, skipTraySlidingAnimation);
		}
	}
}
